File systems employing write back delay significantly reduce the processing penalties that are inherent in file systems employing synchronous write back techniques. With some synchronous write back techniques, if an application modifies file data that is currently stored in a volatile memory (e.g., a random access memory (RAM)) and which is also to be stored in a non-volatile memory (e.g., a disk drive), the application blocks (i.e., prevents further modification of that file data by that application or another application) until the modifications have been committed or written to the non-volatile memory. The non-volatile memory is typically a mass storage device such as, for example, a disk drive having a relatively large latency (i.e., data access or read/write time). As a result, repeated synchronous data write backs provide a high degree of data persistence but introduce significant application processing delays. Furthermore, in cases where the file being modified is part of a distributed file system (e.g., a file system operating within a client server-based system), the synchronous write backs generate a significant amount of network traffic, thereby generating significant network transmission delays that compound the processing delays due to non-volatile memory latency.
In file systems that employ write back delay, programs write data to files via “dirty pages” that are initially stored in volatile memory (e.g., RAM). The newly written data within these dirty pages is periodically (e.g., every thirty seconds) flushed or saved to the non-volatile memory (e.g., a disk drive). In this manner, the write back delay enables the file system to consolidate multiple writes (i.e., data modifications, changes, etc.) to a file (i.e., the dirty pages stored in volatile memory) during the write back delay interval before committing or writing the changes to the non-volatile memory. Such consolidation reduces the overall number of storage operations (e.g., disk writes) to the non-volatile memory, thereby increasing the amount of processor time available for executing an application and increasing the available non-volatile memory bandwidth.
Additionally, in the case of a distributed file system, fewer storage operations (e.g., disk writes by a centralized file server) results in fewer client to server information transfers and, thus, an increase in available network bandwidth. Further, file systems employing write back delay enable the file system to further increase processing efficiency by optimizing the order in which dirty page data is written to the non-volatile memory. Still further, because many applications create and eliminate a significant percentage of files within a relatively short period of time, the write back delay eliminates the need to write back any data associated with a file that expires or is deleted within the write back delay period, thereby further reducing network traffic (in the case of a distributed file system) and increasing overall processing efficiency.
In known file systems, the time period selected for the write back delay achieves a compromise between data persistence and processing performance. In other words, because file data stored in volatile memory may be lost as a result of a power failure or some other processing system event, a longer write back delay increases processing performance at the expense of increasing the probability of losing a file.
Unfortunately, known file systems typically utilize a fixed or static write back delay and, as a result, treat all files equally. For example, data that would be very time consuming to regenerate (e.g., critical data entered by hand) is exposed to the same write back delay period and, thus, the same probability of loss due to system failure or the like as data that would be very easy to regenerate (e.g., data generated in an automated fashion from persistent data sources). Thus, systems employing a static or fixed write back delay fail to consider the time cost of having to re-create and store various types of data and files. In other words, with a fixed write back delay, some files having a relatively low time cost (e.g., files that are easily and quickly regenerated and stored) will be saved to non-volatile memory more often than is optimal, while other files having a relatively high time cost will be saved too infrequently.